# 解除变量与数据的绑定关系
# a01 = None
# 二进制：
# print(0b10)# 2
# 八进制：0  1　．．7  10   11 ..
# print(0o10)# 8
# 十六进制：0 -- 9   a(10) - f(15)
# print(0x10)# 16
# 3.　浮点数float
# print(1.5)
# 科学计数法:表示过小或过大的值很明确
# 1.23e-25
# 地板除（保留整数）
# print(5 // 2)# 商2
# 逻辑运算符  and or not

# 练习：判断年份是否为闰年。
# year = int(input("请输入年份："))
# result = year % 4 == 0 and year % 100 != 0 or year % 400 == 0
# print(result)

# 练习：在控制台中获取两个变量，然后交换数据，最后显示结果.
# data01 = input("请输入第一个变量：")
# data02 = input("请输入第二个变量：")
# 版本１：所有语言通用思想
# temp = data01
# data01 = data02
# data02 = temp
# 版本２：适合ｐｙｔｈｏｎ
# data01, data02 = data02, data01

# 身份运算符
# a = 800
# b = 1000
# print(id(a))  # id函数，可以获取变量存储的对象地址。
# print(id(b))
# print(a is b)  #is的本质就是通过ｉｄ函数进行判断的   结果是flase

# 行
# 三个物理行，三个逻辑行
# a = 1
# b = a + 2
# c = a + b
# 一个物理行，三个逻辑行（不建议）
# a = 1;b = a + 2;c = a + b
# \ 表示折行符
# d = 1 + 2 \
#     +3 + 4  这是一行内容
# 四个物理行，一个逻辑行
# d = (1 +
#      2 +
#      3 +
#      4)

"""
    真值表达式
        if 数据:
            语句
        本质就是使用bool函数操作数据
"""
# 真值表达式
# if "a":
#   # if bool("a"):
    # print("真值")
# str_input = input("请输入：")
# if str_input:
#     print("输入的字符串不是空的")

# while True:
#     usd = int(input("请输入美元："))
#     print(usd * 6.9)
#     if input("输入q键退出:"):
#         break  # 退出循环体

#　累加1--100之间,能被５整除的数字
# sum_value = 0
# for item in range(1,101):
#     满足条件则累加
#     if item % 5 == 0:
#         sum_value+=item
# print(sum_value)

# sum_value = 0
# for item in range(1,101):
#     # 不满足条件则跳过本次循环,继续下次循环。
#     if item % 5 != 0:
#         continue
#     sum_value+=item
# print(sum_value)

# 字　－－> 数
# num01 = ord("a")
# print(num01)

# # 数　－－> 字
# str01 = chr(97)
# print(str01)

# 可见即所得
# name = '''苏大强'''
# name = """
#          苏
#         大
#         强
# """
# print(name)
# 单引号内的双引号不算结束符
# message = '我叫"苏大强"。'
# 双引号内的单引号不算结束符
# message = "我叫'苏大强'。"

# str01 = "悟空"
# str02 = "八戒"
# # 字符串拼接
# str03 = str01 + str02
# # 字符串累加
# str01 += str02
# print(str01)
# 重复生成元素
# print(str02 * 3)#八戒八戒八戒

# 依次比较两个容器中元素,一但不同则返回比较结果。
# print("a悟空" > "b八戒")

#　成员运算符
# print("我叫" in "我叫齐天大圣")

# 索引
# message = "我叫齐天大圣"
# print(message[3])   # 获取正数第三个字
# print(message[-1])  # 获取最后一个字
# 切片
# print(message[0:2])# 我叫
# 开始值默认为开头
# print(message[:2])# 我叫
# 结束值默认为末尾
# print(message[-2:])# 大圣
# print(message[:])#我叫齐天大圣
# print(message[-2:-5:-1])#大天齐  -1表示倒着数
# print(message[::-1])# 圣大天齐叫我
# 索引不能越界  会报错
# print(message[7])
# 切片越界不报错
# print(message[1:7])# 叫齐天大圣

# import random   #随机库
# random_number = random.randint(1, 100)

# count = 0
# while count<3:
#     str_score = input("请输入成绩：")
#     if str_score == "":
#         break# 不会执行else语句
#     score = int(str_score)
#     if score > 100 or score < 0:
#         print("输入有误")
#         count += 1
# else:
#     print("成绩错误过多")

#判断素数
# number = int(input("请输入整数:"))
#判断2 到number之间的数字，能否整除number.
# for item in range(2, number):  # 2 3 4 5 ...
#     if number % item == 0:
#         print("不是素数")
#         break  # 如果发现满足条件的数字，就不再判断后面的了。
# else:
#     print("是素数")

# 练习：获取一个字符串.
# 打印每个字符的编码值
# str_input = input("请输入文字：")
# for item in str_input:
#     print(ord(item))

# 练习:在控制台中，重复录入一个编码值，然后打印字符.
#      如果输入空字符串，则退出程序.
# while True:
#     str_code = input("请输入编码值:")
#     if str_code == "":
#         break
#     code_value = int(str_code)
#     print(chr(code_value))

# len(x)	返回序列的长度
# max(x)	返回序列的最大值元素
# min(x)	返回序列的最小值元素
# sum(x)	返回序列中所有元素的和(元素必须是数值类型)

# age = 800
# score = 99.5
# message = "我叫%s,年龄是%d,成绩是%.1f。" % (name, age, score)
# print(message)

"""
   在控制台中获取一个整数作为边长．
　　根据边长打印矩形．
   例如：４
       ****
       *  *
       *  *
       ****

       6
       ******
       *    *
       *    *
       *    *
       *    *
       ******
"""
# number = int(input("请输入整数:"))  # 4
# print("*" * number)
# for item in range(number - 2):  #
#     print("*" + " " * (number - 2) + "*")
# print("*" * number)

# 在控制台中录入一个字符串，判断是否为回文．
# message = "上海自来水来自海上"
# if message == message[::-1]:
#     print("是回文")
# else:
#     print("不是回文")

# list02=[0,1,2,3]
# for i in range(len(list02) - 1, -1, -1):
#     print(list02[i])
# list02=[-1,-2,-3,-4]
# for i in range(-1, -len(list02) - 1, -1):
#     print(list02[i])

# 列表套列表
# list01 = [800,[1000,500]]
# list02 = list01
# list01[1][0] = 900
# print(list02[1][0])#900  这个要注意

# list01 = [800,[1000,500]]
# 浅拷贝
# 两种浅拷贝的方法
# list02 = list01[:]
# list02 = list01.copy()
# list01[1][0] = 900
# print(list02[1][0])#?900
# 深拷贝
# import copy
# list01 = [800,[1000,500]]
# list02 =copy.deepcopy(list01)
# list01[1][0] = 900
# print(list02[1][0])#?1000

# 缺点：每次循环形成（+=）一个新的字符串对象,替换变量引用result。
# result = ""
# for item in range(10):
#     result = result + str(item)
# 优点：每次循环只向列表添加字符串，没有创建列表对象。
# list_temp = []
# for item in range(10):
#     list_temp.append(str(item))
# join : 把list转换为str类型
# result = " ".join(list_temp)
# print(type(result))
# print(result)

# str01 = "张无忌-赵敏-周芷若"
# list_result = str01.split("-")
# print(list_result)    #['张无忌', '赵敏', '周芷若']

# list_person = []
# 录入过程
# while True:
#     str_input = input("输入在西游记中喜欢的人物:")
#     if str_input == "":
#         break
#     list_person.append(str_input)
# 输出过程
# for item in list_person:
#     print(item)

# list_score = []
# while True:
#     str_score = input("请输入成绩：")
#     if str_score == "":
#         break
#     list_score.append(int(str_score))
# for item in list_score:
#     print(item)
# print("最高分：" + str(max(list_score)))
# print("最低分：" + str(min(list_score)))
# print("平均分：" + str(sum(list_score) / len(list_score)))

# 练习：
# 在控制台中录入，所有学生姓名.
# 如果姓名重复，则提示"姓名已经存在",不添加到列表中.
# 如果录入空字符串，则倒叙打印所有学生.
# list_name = []
# while True:
#     name = input("请输入姓名:")
#     if name == "":
#         break
#     if name not in list_name:
#         list_name.append(name)
#     else:
#         print("姓名已经存在")
# for item in range(-1, -len(list_name) - 1, -1):
#     print(list_name[item])

# max_value = 0
# for item in range(5):
#     number = int(input("请输入第%d个数字:" % (item + 1)))
#     if max_value < number:
#         max_value = number
# print(max_value)

# 练习:在列表中[9, 25, 12, 8]，删除大于10的数字.
# list01 = [9, 25, 12, 8]    #方法一
# for item in list01:
#     if item > 10:
#         list01.remove(item)

# for i in range(len(list01)-1,-1,-1):    方法二
#     if list01[i] > 10:
#         list01.remove(list01[i])
# print(list01)

# 练习:在控制台中循环输入字符串,如果输入空则停止。最后打印所有内容（拼接后的字符串）.
# list_result = []
# while True:
#     str_input = input("请输入：")
#     if str_input == "":
#         break
#     list_result.append(str_input)
# str_result = "".join(list_result)
# print(str_result)

#　练习:英文单词翻转
# "How are you" -->"you are How"
# str01 = "How are you"
# list_temp = str01.split(" ")
# str_result = " ".join(list_temp[::-1])
# print(str_result)

"""
    彩票　双色球：
    红球:6个，1 -- 33 之间的整数   不能重复
    蓝球:1个，1 -- 16 之间的整数
    (1) 随机产生一注彩票[6个红球１个蓝球].
"""
# import random
# list_ticket = []
# # ６个不重复的红球
# while len(list_ticket) < 6:
#     random_number = random.randrange(1, 33)
#     # 如果随机数不存在，则存储。
#     if random_number not in list_ticket:
#         list_ticket.append(random_number)
# # 1个蓝球
# list_ticket.append(random.randrange(1, 16))
# print(list_ticket)

# # ６个1--33范围内的不重复红球号码
# list_ticket = []
# while len(list_ticket) < 6:
#     number = int(input("请输入第%d个红球号码:" % (len(list_ticket) + 1)))
#     if number < 1 or number > 33:
#         print("号码不在范围内")
#     elif number in list_ticket:
#         print("号码已经重复")
#     else:
#         list_ticket.append(number)
# # １个1--16范围内的蓝球号码
# while len(list_ticket) < 7:
#     number = int(input("请输入蓝球号码:"))
#     if 1 <= number <= 16:
#         list_ticket.append(number)
#     else:
#         print("号码不在范围内")
# print(list_ticket)

# 将list01中所有元素,增加１以后存入list02中.
# list01 = [5, 56, 6, 7, 7, 8, 19]
# list02 = []
# for item in list01:
#     list02.append(item + 1)
# 列表推导式
# list02 = [item + 1 for item in list01]
# print(list02)

# 将list01中大于１０元素,增加１以后存入list02中.
# list02 = []
# for item in list01:
#     if item >10:
#         list02.append(item + 1)
# 列表推导式
# list02 = [item + 1 for item in list01 if item > 10]

# tuple01 = ()
# 列表　--> 元组
# tuple01 = tuple(["a", "b"])

# 如果元组只有一个元素
# tuple02 = (100)  #这就是一个简单的100
# print(type(tuple02))# int

# 元组的数据不能变化
# tuple02[0] = 10

# tuple03 = ("a", "b", "c", "d")
# e01 = tuple03[1]
# print(e01)    #b
# print(type(e01))  # str
# e02 = tuple03[-2:]
# print(e02)    #('c', 'd')
# print(type(e02))  # tuple

# 可以直接将元组赋值给多个变量
# tuper04 = (100, 200)
# a, b = tuper04
# print(a)
# print(b)

# 遍历元素
# 正向
# for item in tuper04:
#     print(item)
# 反向
# 1  0
# for i in range(len(tuper04) - 1, -1, -1):
#     print(tuper04[i])

# dict01 = {}
# dict01 = dict()
# dict01 = {"wj":100,"zm":80,"zr":90}
# dict01 = dict([("a","b"),("c","d")])
# print(dict01)

# 查找元素(根据ｋｅｙ查找ｖａｌｕｅ)
# print(dict01["a"])
# 如果ｋｅｙ不存在，查找时会错误.
# if "qtx" in dict01:# 如果存在key
#     print(dict01["qtx"])

# 修改元素(之前存在key)  根据key改value
# dict01["a"] = "BB"

# 添加(之前不存在ｋｅｙ)
# dict01["e"] = "f"

# 删除
# del dict01["a"]

dict01 = {"wj":100,"zm":80,"zr":90}
# 遍历字典，获取key
# for key in dict01:
#     print(key)
#     print(dict01[key])
# 遍历字典，获取value
# for value in dict01.values():
#     print(value)

# 遍历字典，获取键值对key value(元组). 下面是两种方法
# for item in dict01.items():
#     print(item[0])
#     print(item[1])

# for k,v in dict01.items():
#     print(k)
#     print(v)

# 练习:使用range生成1--10之间的数字,将数字的平方存入list01中
# 将list01中所有奇数存入list02
# 将list01中所有偶数存入list03
# 将list01中所有偶数大于5的数字增加1后存入list04
# list01 = [item ** 2 for item in range(1, 11)]
# list02 = [item for item in list01 if item % 2 == 1]
# list03 = [item for item in list01 if item % 2 == 0]
# list04 = [item + 1 for item in list01 if item % 2 == 0 and item > 5]

# month = int(input("请输入月份："))
#
# if month < 1 or month > 12:
#     print("输入有误")
# elif month == 2:
#     print("２８天")
# elif month == 4 or month == 6 or month == 9\
#         or month == 11:
#     print("３０天")
# else:
#     print("３１天")

# month = int(input("请输入月份："))
#
# if month < 1 or month > 12:
#     print("输入有误")
# elif month == 2:
#     print("２８天")
# elif month in (4,6,9,11):
#     print("３０天")
# else:
#     print("３１天")

# month = int(input("请输入月份："))
# if month < 1 or month > 12:
#     print("输入有误")
# else:
#     # 将每月天数存入元组
#     day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
#     print(day_of_month[month - 1])

# 练习:在控制台中录入日期(月日)，计算这是这一年的第几天.
# day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# month = int(input("请输入月份"))
# day = int(input("请输入日："))
# 方法一：
# #先累加前几个月天数   再累加当月天数
# total_day = 0
# for i in range(month - 1):
#     total_day += day_of_month[i]
# total_day += day
# print("是这年的第%d天." % total_day)

# 方法二:
# total_day = sum(day_of_month[:month - 1])
# total_day += day
# print("是这年的第%d天." % total_day)

# dict_commodity_info = {}
# while True:
#     name = input("请输入商品名称：")
#     if name == "":
#         break
#     price = int(input("请输入商品单价："))
#     dict_commodity_info[name] = price
# for key,value in dict_commodity_info.items():
#     print("%s商品单价是%d"%(key,value))

"""
# 字典内嵌字典:
{
    "张无忌":{"age":28,"score":100,"sex":"男"},
}
"""
# dict_student_info = {}
# while True:
#     name = input("请输入姓名：")
#     if name == "":
#         break
#     age = int(input("请输入年龄："))
#     score = int(input("请输入成绩："))
#     sex = input("请输入性别：")
#     dict_student_info[name] = {"age": age, "score": score, "sex": sex}
# for name, dict_info  in dict_student_info.items():
#     print("%s的年龄是%d,成绩是%d,性别是%s" %(name, dict_info["age"],dict_info["score"], dict_info["sex"]))

"""
# 列表内嵌字典:
[
    {"name":"张无忌","age":28,"score":100,"sex":"男"},
]
"""
# list_student_info = []
# while True:
#     name = input("请输入姓名：")
#     if name == "":
#         break
#     age = int(input("请输入年龄："))
#     score = int(input("请输入成绩："))
#     sex = input("请输入性别：")
#     dict_info = {"name": name, "age": age, "score": score, "sex": sex}
#     list_student_info.append(dict_info)
# for dict_info in list_student_info:
#     print("%s的年龄是%d,成绩是%d,性别是%s" % (dict_info["name"], dict_info["age"], dict_info["score"], dict_info["sex"]))
# 获取第一个学生信息
# dict_info = list_student_info[0]
# print("第一个录入的是：%s,年龄是%d,成绩是%d,性别是%s" % (dict_info["name"], dict_info["age"], dict_info["score"], dict_info["sex"]))

"""
总结：
 　　存储多个学生信息(姓名,年龄,成绩,性别)的多种方式
1. 字典内嵌列表:
{
    "张无忌":[28,100,"男"],
}
2. 字典内嵌字典:
{
    "张无忌":{"age":28,"score":100,"sex":"男"},
}
3. 列表内嵌字典:
[
    {"name":"张无忌","age":28,"score":100,"sex":"男"},
]
4. 列表内嵌列表
[
    ["张无忌",28,100男],
]
选择策略：根据具体需求，结合优缺点，综合考虑(两害相权取其轻).
    字典：
        优点：根据键获取值，读取速度快；
        　　　代码可读性相对列表更高(根据键获取与根据索引获取).
        缺点：内存占用大；
        　　　获取值只能根据键,不灵活.
    列表：
        优点：根据索引/切片，获取元素更灵活.
             相比字典占内存更小。
        缺点：通过索引获取，如果信息较多，可读性不高.
"""

# 练习:在控制台中录入多个人的多个喜好,输入空字符停止.
"""  列表套字典  字典套列表
[
    {“无忌”:[赵敏,周芷若,小赵]}
]
"""
# list_person_bobby = []
# while True:
#     name = input("请输入姓名：")
#     if name == "":
#         break
#     dict_person = {name:[]}
#     list_person_bobby.append(dict_person)
#     while True:
#         bobby = input("请输入喜好：")
#         if bobby == "":
#             break
#         dict_person[name].append(bobby)
"""
{   字典套字典  再套列表
    “无忌”:[赵敏,周芷若,小赵]
}
"""
# dict_person_bobby = {}
# while True:
#     name = input("请输入姓名：")
#     if name == "":
#         break
#     dict_person_bobby[name] = []
#     while True:
#         bobby = input("请输入喜好：")
#         if bobby == "":
#             break
#         dict_person_bobby[name].append(bobby)
# for name, list_bobby in dict_person_bobby.items():
#     print("%s喜欢：" % name)
#     for item in list_bobby:
#         print(item)

# 将1970年到2050年中的闰年，存入列表．
# list_result = []
# for item in range(1970, 2051):
#     if item % 4 == 0 and item % 100 != 0 or item % 400 == 0:
#         list_result.append(item)
# print(list_result)
# list_result = [item for item in range(1970, 2051) if item % 4 == 0 and item % 100 != 0 or item % 400 == 0]
# print(list_result)

"""
 存储全国各个城市的景区与美食(不用录入),在控制台中显示出来.
  　北京：
        景区：故宫,天安门,天坛.
        美食: 烤鸭,炸酱面,豆汁,卤煮.
    四川:
        景区：九寨沟,峨眉山,春熙路．
        美食: 火锅,串串香,兔头.
"""
# dict01 = {
#     "北京":
#         {
#             "景区": ["故宫", "天安门", "天坛"],
#             "美食": ["烤鸭", "炸酱面", "豆汁", "卤煮"]
#         },
#     "四川":
#         {
#             "景区": ["九寨沟", "峨眉山", "春熙路"],
#             "美食": ["火锅", "串串香", "兔头"]
#         }
# }
# 需求:获取四川的所有美食
# print(dict01["四川"]["美食"])
# 需求:获取所有城市
# for key in dict01:
#     print(key)
# 需求：所有城市的景区
# print(dict01["四川"]["景区"])
# print(dict01["北京"]["景区"])
# print(dict01["xxx"]["景区"])

# list02 = []
# # 遍历大字典，获取地区
# for key in dict01:
#     # 遍历景区列表
#     for item in dict01[key]["景区"]:
#         # 地区+景区
#         list02.append(key + ":" + item)
# print(list02)

# 计算一个字符串中的字符以及出现的次数.
# 思想：逐一判断字符出现的次数.如果统计过则增加１，如果没统计过则等于１.
# dict_result = {}
# str_target = "abcdefce"
# for item in str_target:
#     if item not in dict_result:
#         dict_result[item] = 1
#     else:
#         dict_result[item] += 1
# print(dict_result)

# 字典推导式
# dict01 = {}
# for item in range(1, 11):
#     dict01[item] = item ** 2
# print(dict01)
# dict02 = {item: item ** 2 for item in range(1, 11)}
# print(dict02)
#
# 只记录大于５的数字
# dict01 = {}
# for item in range(1, 11):
#     if item >5:
#         dict01[item] = item ** 2
# print(dict01)
# dict02 = {item: item ** 2 for item in range(1, 11) if item >5}
# print(dict02)

# 集合set
# set01 = set("abcac")
# list01 = list(set01)
# str01 = "".join(list01)
# print(str01)  # "bca"

# 添加元素
# set02.add("qtx")
# 删除元素
# set02.remove("a")
# 获取所有元素
# for item in set02:
#     print(item)

# 数学运算
# set01 = {1, 2, 3}
# set02 = {2, 3, 4}
# 交集
# print(set01 & set02)  # {2,3}
# 并集
# print(set01 | set02)  # {1, 2, 3, 4}
# 补集
# print(set01 ^ set02)  # {1, 4}
# print(set01 - set02) # {1}
# print(set02 - set01) # {4}
# 子集
# set03 = {1, 2}
# print(set03 < set01)  #True
# 超集
# print(set01 > set03)  #True

# 固定集合是不可变的，无序的，含有唯一元素的集合(可以看成一个不可以改变的集合)
# 作用：固定集合可以作为字典的键，还可以作为集合的值  d = { frozenset({1,2,3}):"123" }
# set01 = frozenset([1,2,3,3,5])
# list02 = list(set01)
# print(set01)
# print(list02)

# 列表推导式嵌套
# list01 = ["a", "b", "c"]
# list02 = ["A", "B", "C"]
# list03 = []
# for r in list01:
#     for c in list02:
#         list03.append(r + c)
# print(list03)
#
# list04 = [r + c for r in list01 for c in list02]
# print(list04)

# 练习:列表的全排列
# [“香蕉”,"苹果","哈密瓜"]
# [“可乐”,"牛奶"]
# list01 = ["香蕉","苹果","哈密瓜"]
# list02 = ["可乐","牛奶"]
# list03 = []
# for r in list01:
#     for c in list02:
#         list03.append(r+c)
# list04 = [r+c for r in list01 for c in list02]
# print(list03)
# print(list04)

# 定义（做功能）函数
# def attack():
#     """
#         单次攻击　
#     """
#     print("临门一脚")
#     print("直拳")
#     print("摆拳")
#     print("肘击")

# 形式参数
# def attack_repeat(count):
#     """
#         重复攻击
#     :param count: 攻击次数,int类型
#     """
#     for i in range(count):
#         print("临门一脚")
#         print("直拳")
#         print("摆拳")
#         print("肘击")

# 调用函数
# attack()
# attack_repeat(2)

# 练习1:["无忌","赵敏","周芷若"]
#    ->{"无忌":2,"赵敏":2,"周芷若":3}
# list01 = ["无忌", "赵敏", "周芷若"]
# dict01 = {}
# for item in list01:
#     dict01[item] = len(item)
# dict02 = {item: len(item) for item in list01}
# print(dict01)
# print(dict02)

# 练习2:["无忌","赵敏","周芷若"]  [101,102,103]
#  {"无忌":101,"赵敏":102,"周芷若":103}
# list01 = ["无忌", "赵敏", "周芷若"]
# list02 = [101, 101, 103]
# dict01 = {}
# 通过索引同时在多个列表中获取元素
# for i in range(len(list01)):
#     # key = list01[i]
#     # value = list02[i]
#     # dict01[key] = value
#     dict01[list01[i]] = list02[i]
# print(dict01)

# 需求：字典如何根据value查找key
# 解决方案１:键值互换
# dict02 = {value: key for key, value in dict01.items()}
# print(dict02)
# print(dict02[101])
# 缺点:如果key重复,交换或则丢失数据。
# 因此当如果需要保持所有数据时，采用下面这种方法
# list02 = [(value, key) for key, value in dict01.items()]
# print(list02)

# 练习1: 在控制台中循环录入字符串，输入空字符停止.
#       打印所有不重复的文字
# 看到不重复就想到字典
# set_result = set()
# while True:
#     str_input = input("请输入：")
#     if str_input == "":
#         break
#     set_result.add(str_input)
# print(set_result)

# 练习: 经理：曹操,刘备,孙权
#       技术：曹操,刘备,张飞,关羽
# 请计算：
#      (1)是经理也是技术的有谁？
#      (2)是经理，不是技术的有谁?
#      (3)是技术，不是经理的有谁?
#      (4)张飞是经理吗?
#      (5)身兼一职的都有谁?
#      (6)经理和技术总共有都少人?
# set01 = {"曹操", "刘备", "孙权"}
# set02 = {"曹操", "刘备", "张飞", "关羽"}
# print(set01 & set02)
# print(set01 - set02)
# print(set02 - set01)
# print("张飞" in set01)
# print(set01 ^ set02)
# print(len(set01 | set02))

# 列表排序(升序小　-->  大)
# [3,80,45,5,7,1]
# 目标:列表中所有元素两两比较
# 思想:
# 　取出第一个元素,与后面元素进行比较.
# 　取出第二个元素,与后面元素进行比较.
# 　取出第三个元素,与后面元素进行比较.
#   ...
#   取出倒数第二个元素,与后面元素进行比较.
#   如果取出的元素大于(>)后面的元素,
#       则交换

# list01 = [3, 80, 45, 5, 7, 1]
# for r in range(len(list01) - 1):
#     for c in range(r + 1, len(list01)):
#         if list01[r] > list01[c]:
#             list01[r], list01[c] = list01[c], list01[r]
# print(list01)

# """
#     练习:
#     判断列表中元素是否具有相同的[3,80,45,5,80,1]
#     思路：所有元素俩俩比较,发现相同的则打印结果
#     　　　所有元素比较结束，都没有发现相同项，则打印结果.
# """
# list01 = [3, 81, 3, 5, 81, 5]
# result = False
# for r in range(0, len(list01) - 1):
#     for c in range(r + 1, len(list01)):
#         if list01[r] == list01[c]:
#             print("具有相同项")
#             result = True
#             break  # 退出循环
#     if result:
#         break
# if result == False:
#     print("没有相同项")

# 练习:矩阵转置  将二维列表的列，变成行，形成一个新列表.
# list01 = [
#     [1,2,3,4],
#     [5,6,7,8],
#     [9,10,11,12],
#     [13,14,15,16],
# ]
#方法一
# result = []
# for c in range(4):
#     line = []
#     result.append(line)
#     #00   10   20  30
#     for r in range(4):
#         line.append(list01[r][c])
#方法二
# result = []
# for c in range(len(list01[0])):
#     result.append([])
#     for r in range(len(list01)):
#         result[c].append(list01[r][c])
# print(result)

# 练习:列表的全排列
# [“香蕉”,"苹果","哈密瓜"]
# [“可乐”,"牛奶"]
# list01 = ["香蕉","苹果","哈密瓜"]
# list02 = ["可乐","牛奶"]
# list03 = []
# for r in list01:
#     for c in list02:
#         list03.append(r+c)
# list04 = [r+c for r in list01 for c in list02]
# print(list03)
# print(list04)

# 练习:将下列代码，定义到函数中，再调用一次.
# def print_rectangle(r_count,c_count,char):
#     """
#         打印矩形
#     :param r_count: 行数
#     :param c_count: 列数
#     :param char: 填充的字符　
#     """
#     for r in range(r_count):
#         # 内层循环控制列　
#         for c in range(c_count):
#             print(char, end=" ")
#         print()
# print_rectangle(5,2,"#")

# 练习:定义在控制台中打印一维列表的函数.
# 例如：[1,2,3]-->1 2 3  每个元素一行
# def print_list(list_target):
#     """
#         打印列表
#     :param list_target: 目标列表　
#     """
#     for item in list_target:
#         print(item)
# list01 = [1, 2, 3]
# list02 = ["a", True, 1.5, 10]
# print_list(list02)

"""
3. 定义在控制台中打印二维列表的函数
[
    [1,2,3,44],
    [4,5,5,5,65,6,87],
    [7,5]
]
1 2 3 44
4 5 5 5 65 6 87
7 5
"""
# def print_double_list(double_list):
#     """
#         打印二维列表
#     :param double_list: 需要打印的二维列表
#     """
#     for line in double_list:
#         for item in line:
#             print(item, end=" ")
#         print()
# list01 = [
#     [1, 2, 3, 44],
#     [4, 5, 5, 5, 65, 6, 87],
#     [7, 5]
# ]
# print_double_list(list01)

# 方阵转置.（不用做成函数）
# list01 = [
#     [1, 2, 3, 4],
#     [5, 6, 7, 8],
#     [9, 10, 11, 12],
#     [13, 14, 15, 16],
# ]
"""
#list01[1][0] <->list01[0][1]
#list01[2][0] <->list01[0][2]
#list01[3][0] <->list01[0][3]
for r in range(1,4):
    #list01[r][0]<->list01[0][r]
    pass

#list01[2][1] <->list01[1][2]
#list01[3][1] <->list01[1][3]
for r in range(2,4):#2 3
    # list01[r][1] <->list01[1][r]
    pass

#list01[3][2] <->list01[2][3]
for r in range(3,4):
    # list01[r][2] <->list01[2][r]
    pass

for c in range(1,4):#1 2 3
    for r in range(c,4):
        list01[r][c-1],list01[c-1][r]=list01[c-1][r],list01[r][c-1]
"""
# for c in range(1, len(list01)):  # 1 2 3
#     for r in range(c, len(list01)):
#         list01[r][c - 1], list01[c - 1][r] = list01[c - 1][r], list01[r][c - 1]
#
# print(list01)

# 全局变量
# g01 = "ok"
# def fun01():
#     # 局部变量：在函数内部定义的变量
#     l01 = 100
#     print(l01)
#     print(l01)
#     # 在函数内部可以读取全局变量
#     print(g01)
#     # 还可以再创建了一个局部变量也叫g01，但不是修改全局变量
#     g01 = "no"
#     # 定义全局变量g01  此时修改的是全局变量
#     global g01
#     g01 = "no"
#     print(g01)

# def fun01(a, b, c, d):
#     print(a)
#     print(b)
#     print(c)
#     print(d)

# 位置实参：实参与形参根据位置进行依次对应.
# fun01(1, 2, 3, 4)

# 关键字实参:实参与形参根据名称进行对应
# fun01(b=1, d=2, c=3, a=4)

# 序列实参:星号将序列拆分后按位置与形参进行对应
#     如果参数很多，可以存储在序列(字符串/列表/元组)中,再通过*拆分,直接传入函数.
# list01 = ["a","b","c","d"]
# fun01(*list01)

# 字典实参:双星号将字典拆分后按名称与形参进行对应  如果参数很多，可以存储在字典中,再通过**拆分,传入函数.
# dict01 = {"a": 1, "c": 3, "d": 4, "b": 2}
# fun01(**dict01)

# 1. 缺省(默认)形参:如果实参不提供，可以使用默认值.
# def fun01(a=None, b=0, c=0, d=0):
#     print(a)
#     print(b)
#     print(c)
#     print(d)

# 关键字实参 + 缺省形参:调用者可以随意传递参数.
# fun01(b=2, c=3)

# 位置形参
# def fun02(a, b, c, d):
#     print(a)
#     print(b)
#     print(c)
#     print(d)

# 星号元组形参: * 将所有实参合并为一个元组
# 作用：让实参个数无限
# def fun03(*args):
#     print(args)
# fun03()       # ()
# fun03(1)      # (1,)
# fun03(1,"2")  # (1, '2')

# 命名关键字形参:在星号元组形参以后的位置形参
# 目的：要求实参必须使用关键字实参.
# def fun04(a, *args, b):
#     print(a)
#     print(args)
#     print(b)

# fun04(1, b=2)
# fun04(1, 2, 3, 4, b=2)

# def fun05(*, a, b):
#     print(a)
#     print(b)

# fun05(a=1, b=2)

# 双星号字典形参：**目的是将实参合并为字典.
#               实参可以传递数量无限的关键字实参.
# def fun06(**kwargs):
#     print(kwargs)
#
# fun06(a=1, b=2)

# 调用fun07
# def fun07(a, b, *args, c, d, **kwargs):
#     pass

# def each_unit_sum(number):
#     """
#         计算4位整数的每位相加和
#     :param number: 四位整数
#     :return: 相加的结果
#     """
#     result = number % 10
#     result += number // 10 % 10
#     result += number // 100 % 10
#     result += number // 1000
#     return result
# re01 = each_unit_sum(1234)
# print(re01)

# 练习:定义　判断列表中是否存在相同元素的　函数
# def is_repeating(list_target):
#     for r in range(0, len(list_target) - 1):
#         for c in range(r + 1, len(list_target)):
#             if list_target[r] == list_target[c]:
#                 return "具有相同项"
#     return "没有相同项"
# print(is_repeating([3, 8, 23, 5, 81, 1]))

# 定义函数,根据年月，计算有多少天。考虑闰年29天，平年28天
# def get_day_by_month(year, month):
#     if month < 1 or month > 12:
#         return False
#     if month == 2:
#         if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
#             return 29
#         else:
#             return 28
#     if month in (4, 6, 9, 11):
#         return 30
#     return 31

# def is_leap_year(year):
#      #   if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
#      #        return True
#      #   else:
#      #        return False
#     return year % 4 == 0 and year % 100 != 0 or year % 400 == 0

# def get_day_by_month(year, month):
#     if month < 1 or month > 12:
#         return 0
#     if month == 2:
#         if is_leap_year(year):
#             return 29
#         else:
#             return 28
#     if month in (4, 6, 9, 11):
#         return 30
#     return 31

# def get_day_by_month(year, month):
#     if month < 1 or month > 12:
#         return 0
#     if month == 2:
#         return 29 if is_leap_year(year) else 28
#     if month in (4, 6, 9, 11):
#         return 30
#     return 31
# print(get_day_by_month(2019,5))

# 定义列表升序排列的函数
# def sort(list_target):
#     for r in range(len(list_target) - 1):
#         for c in range(r + 1, len(list_target)):
#             if list_target[r] > list_target[c]:
#                 list_target[r], list_target[c] = list_target[c], list_target[r]
# list01 = [43, 4, 5, 6, 7]
# sort(list01)
# print(list01)

# 练习：定义方阵转置函数
# def square_matrix_transpose(sqr_matrix):
#     """
#         方阵转置
#     :param sqr_matrix: 二维列表类型的方阵
#     """
#     for c in range(1, len(sqr_matrix)):
#         for r in range(c, len(sqr_matrix)):
#             sqr_matrix[r][c - 1], sqr_matrix[c - 1][r] = sqr_matrix[c - 1][r], sqr_matrix[r][c - 1]

# list01 = [
#     [1, 2, 3, 4],
#     [5, 6, 7, 8],
#     [9, 10, 11, 12],
#     [13, 14, 15, 16],
# ]
# square_matrix_transpose(list01)
# print(list01)
# square_matrix_transpose(list01)
# print(list01)

# 练习:定义函数，根据小时，分钟，秒，计算总秒数.
# 要求：可以只计算小时-->秒
# 　　　可以只计算分钟-->秒
# 　　　可以只计算小时＋分钟-->秒
# 　　　可以只计算小时＋秒-->秒
# def get_total_second(hour=0, minute=0, second=0):
#     return hour * 3600 + minute * 60 + second
# 小时，分钟，秒，
# print(get_total_second(1, 1, 1))
# 小时，分钟
# print(get_total_second(2, 3))
# 分钟，秒，
# print(get_total_second(minute=2, second=3))
# 小时，
# print(get_total_second(2))
# 分钟，
# print(get_total_second(minute=2))

# 练习:定义函数，数值相加的函数.
# def adds(*args):
#     # result = 0
#     # for item in args:
#     #     result += item
#     # return result
#     return sum(args)
# print(adds(1, 22, 3, 3, 4, 5, 6))
# print(adds(1, 4, 5, 6))

# 定义函数，计算指定范围内的素数
# def get_prime(begin,end):#5  30
#     list_result = []
#     # 生成范围内的整数
#     for number in  range(begin,end):
#         # 判断素数
#         for item in range(2, number):
#             if number % item == 0:
#                 break
#         else:
#             list_result.append(number)
#     return list_result

# def is_prime(number):
#     """
#     判断指定的数字是否为素数
#     :param
#     number: 指定的整数
#     :return: True
#     表示是素数，False表示不是素数.
#     """
#     for item in range(2, number):
#         if number % item == 0:
#             return False
#     return True

# def get_prime(begin, end):  # 5  30
#     \"""
#         获取范围内的素数
#     :param begin: 开始值(包含)
#     :param end: 结束值(不包含)
#     :return: 所有素数的列表
#     \"""
#     list_result = []
#     for number in range(begin, end):
#         if is_prime(number):
#             list_result.append(number)
#     return list_result

# def get_prime(begin, end):  # 5  30
#     """"
#     获取范围内的素数
#     :param
#     begin: 开始值(包含)
#     :param
#     end: 结束值(不包含)
#     :return: 所有素数的列表
#     """
#     return [number for number in range(begin, end) if is_prime(number)]
# print(get_prime(5, 30))

# shang_pin_info = {
#     101: {"name": "屠龙刀", "price": 10000},
#     102: {"name": "倚天剑", "price": 10000},
#     103: {"name": "九阴白骨爪", "price": 8000},
#     104: {"name": "九阳神功", "price": 9000},
#     105: {"name": "降龙十八掌", "price": 8000},
#     106: {"name": "乾坤大挪移", "price": 10000}
# }
# ding_dan = []
# def gou_wu():
#     """
#         购物
#     :return:
#     """
#     while True:
#         item = input("1键购买，2键结算。")
#         if item == "1":
#             for key, value in shang_pin_info.items():
#                 print("编号：%d，名称：%s，单价：%d。" % (key, value["name"], value["price"]))
#             while True:
#                 cid = int(input("请输入商品编号："))
#                 if cid in shang_pin_info:
#                     break
#                 else:
#                     print("该商品不存在")
#             count = int(input("请输入购买数量："))
#             ding_dan.append({"cid": cid, "count": count})
#             print("添加到购物车。")
#         elif item == "2":
#             zong_jia = 0
#             for item in ding_dan:
#                 shang_pin = shang_pin_info[item["cid"]]
#                 print("商品：%s，单价：%d,数量:%d." % (shang_pin["name"], shang_pin["price"], item["count"]))
#                 zong_jia += shang_pin["price"] * item["count"]
#             while True:
#                 qian = float(input("总价%d元，请输入金额：" % zong_jia))
#                 if qian >= zong_jia:
#                     print("购买成功，找回：%d元。" % (qian - zong_jia))
#                     ding_dan.clear()
#                     break
#                 else:
#                     print("金额不足.")
# gou_wu()

